#ifndef _THREAD_HPP__
#define _THREAD_HPP__

#include <iostream>
#include <string>
#include <functional>
#include <sys/types.h>
#include <unistd.h>

namespace bit_thread
{
    typedef std::function<void()> func_t;
    static int number = 1; // 编号从1开始
    enum class TSTATUS
    {
        NEW,     // 线程是新建的
        RUNNING, // 线程是启动的
        STOP     // 线程是停止的
    };
    class Thread
    {
    private:
        void EnableDetach() { _joinable = false; } // 设置成分离

        static void *Routine(void *args)
        {
            // args接收的是this,然后强转成Thread*
            Thread *t = static_cast<Thread *>(args);
            t->_status = TSTATUS::RUNNING;
            // 执行传入的方法
            t->_func();
            return nullptr;
        }

    public:
        Thread(func_t func) : _func(func), _status(TSTATUS::NEW), _joinable(true) // 执行什么方法传过来
        {
            // 线程名称+编号
            _name = "Thread-" + std::to_string(number++);
            _pid = getpid();
        }
        ~Thread()
        {
        }
        // 启动线程
        bool Start()
        {
            // 判断防止重复启动
            if (_status != TSTATUS::RUNNING)
            {
                int n = ::pthread_create(&_tid, nullptr, Routine, this);
                if (n != 0)
                    return false;

                return true;
            }
            return false;
        }
        // 停止
        bool Stop()
        {
            if (_status == TSTATUS::RUNNING)
            {
                int n = ::pthread_cancel(_tid);
                if (n != 0)
                    return false;
                _status = TSTATUS::STOP;
                return true;
            }
            return false;
        }
        // 等待线程
        bool Join()
        {
            if (_joinable == true)
            {
                int n = ::pthread_join(_tid, nullptr);
                if (n != 0)
                    return false;

                _status = TSTATUS::STOP;

                return true;
            }
            return false;
        }
        // 线程分离
        void Detach()
        {
            EnableDetach(); // 分离
            pthread_detach(_tid);
        }

        // 是否被分离
        bool EnableJoinable() { return _joinable; }
        std::string Name(){return _name;}

    private:
        std::string _name; // 线程名称
        pthread_t _tid;    // 线程id
        pid_t _pid;        // 进程id--当前线程属于那个进程
        bool _joinable;    // 线程是否分离--默认不是
        func_t _func;      // 任务
        TSTATUS _status;   // 线程状态
    };
}

#endif